home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Demos / ByCompany / TipTop_Software / TipTop / Supplement / src / Z301 / sz.c < prev    next >
Text File  |  1994-05-08  |  45KB  |  2,133 lines
  1. #define VERSION "sz 3.03 5-09-89"
  2. #define PUBDIR "/usr/spool/uucppublic"
  3.  
  4. /*% cc -compat -M2 -Ox -K -i -DTXBSIZE=16384  -DNFGVMIN -DREADCHECK sz.c -lx -o sz; size sz
  5.  
  6. /*% cc -Zi -DXX -DNFGVMIN -DREADCHECK sz.c -lx -o xsz; size xsz
  7. <-xtx-*> cc -Osal -DTXBSIZE=32768  -DSV sz.c -lx -o $B/sz; size $B/sz
  8.  
  9.  ****************************************************************************
  10.  *
  11.  * sz.c By Chuck Forsberg,  Omen Technology INC
  12.  *
  13.  ****************************************************************************
  14.  *
  15.  * Typical Unix/Xenix/Clone compiles:
  16.  *
  17.  *    cc -O sz.c -o sz        USG (SYS III/V) Unix
  18.  *    cc -O -DSV sz.c -o sz        Sys V Release 2 with non-blocking input
  19.  *                    Define to allow reverse channel checking
  20.  *    cc -O -DV7  sz.c -o sz        Unix Version 7, 2.8 - 4.3 BSD
  21.  *
  22.  *    cc -O -K -i -DNFGVMIN -DREADCHECK sz.c -lx -o sz    Classic Xenix
  23.  *
  24.  *    ln sz sb            **** All versions ****
  25.  *    ln sz sx            **** All versions ****
  26.  *
  27.  ****************************************************************************
  28.  *
  29.  * Typical VMS compile and install sequence:
  30.  *
  31.  *        define LNK$LIBRARY   SYS$LIBRARY:VAXCRTL.OLB
  32.  *        cc sz.c
  33.  *        cc vvmodem.c
  34.  *        link sz,vvmodem
  35.  *    sz :== $disk$user2:[username.subdir]sz.exe
  36.  *
  37.  *  If you feel adventureous, remove the #define BADSEEK line
  38.  *  immediately following the #ifdef vax11c line!  Some VMS
  39.  *  systems know how to fseek, some don't.
  40.  *
  41.  ****************************************************************************
  42.  *
  43.  *
  44.  * A program for Unix to send files and commands to computers running
  45.  *  Professional-YAM, PowerCom, YAM, IMP, or programs supporting Y/XMODEM.
  46.  *
  47.  *  Sz uses buffered I/O to greatly reduce CPU time compared to UMODEM.
  48.  *
  49.  *  USG UNIX (3.0) ioctl conventions courtesy Jeff Martin
  50.  *
  51.  *    This version implements ZMODEM Run Length Encoding, Comparision,
  52.  *    and variable length headers.  These features were not funded
  53.  *    by the original Telenet development contract.  This software,
  54.  *    including these features, may be freely used for non
  55.  *    commercial and educational purposes.  This software may also
  56.  *    be freely used to support file transfer operations to or from
  57.  *    licensed Omen Technology products.  Contact Omen Technology
  58.  *    for licensing for other uses.  Any programs which use part or
  59.  *    all of this software must be provided in source form with this
  60.  *    notice intact except by written permission from Omen
  61.  *    Technology Incorporated.
  62.  *
  63.  *        Omen Technology Inc        FAX: 503-621-3745
  64.  *        Post Office Box 4681
  65.  *        Portland OR 97208
  66.  *
  67.  *    Previous versions of this program (not containing the extensions
  68.  *    listed above) remain in the public domain.
  69.  *
  70.  *    This code is made available in the hope it will be useful,
  71.  *    BUT WITHOUT ANY WARRANTY OF ANY KIND OR LIABILITY FOR ANY
  72.  *    DAMAGES OF ANY KIND.
  73.  *
  74.  *  2.1x hacks to avoid VMS fseek() bogosity, allow input from pipe
  75.  *     -DBADSEEK -DTXBSIZE=32768  
  76.  *  2.x has mods for VMS flavor
  77.  *
  78.  * 1.34 implements tx backchannel garbage count and ZCRCW after ZRPOS
  79.  * in accordance with the 7-31-87 ZMODEM Protocol Description
  80.  */
  81.  
  82. #ifdef NeXT
  83. #import <objc/objc.h>
  84. #import "TransferProgressProtocol.h"
  85. id getProgressListener();
  86. static id remote;
  87. #endif
  88.  
  89.  
  90. #ifdef XX
  91. #define XARGSFILE "args"
  92. long Thisflen;
  93. #endif
  94.  
  95. char *substr(), *getenv();
  96.  
  97. #ifdef vax11c
  98. #define STATIC
  99. #define BADSEEK
  100. #define TXBSIZE 32768        /* Must be power of two, < MAXINT */
  101. #include <types.h>
  102. #include <stat.h>
  103. #define STAT
  104. #define LOGFILE "szlog.tmp"
  105. #include <stdio.h>
  106. #include <signal.h>
  107. #include <setjmp.h>
  108. #include <ctype.h>
  109. #include <errno.h>
  110. #define OS "VMS"
  111. #define ROPMODE "r"
  112. #define READCHECK
  113. #define BUFWRITE
  114. extern int errno;
  115. #define SS_NORMAL SS$_NORMAL
  116. #define xsendline(c) sendline(c)
  117.  
  118. #ifndef PROGNAME
  119. #define PROGNAME "sz"
  120. #endif
  121.  
  122.  
  123. #else    /* vax11c */
  124.  
  125. #ifdef GENIE
  126. #define STATIC static
  127. #define LOGFILE "szlog"
  128. #define BADSEEK
  129. #define TXBSIZE 32768        /* Must be power of two, < MAXINT */
  130. #define OS "GEnie"
  131. #define SS_NORMAL 0
  132. #include <stdio.h>
  133. #include <signal.h>
  134. #include <setjmp.h>
  135. #include <ctype.h>
  136. #include <errno.h>
  137. #include <stdlib.h>
  138. #include <fildes.h>
  139. FILDES fdes;
  140. extern int errno;
  141. int Binfile;
  142. long Thisflen;
  143.  
  144. #define sendline(c) putchar(c & 0377)
  145. #define xsendline(c) putchar(c)
  146.  
  147. #else    /* GENIE */
  148.  
  149. #define LOGFILE "/tmp/szlog"
  150. #define SS_NORMAL 0
  151. #include <stdio.h>
  152. #include <signal.h>
  153. #include <setjmp.h>
  154. #include <ctype.h>
  155. #include <errno.h>
  156. extern int errno;
  157. #define STATIC
  158.  
  159. #define sendline(c) putchar(c & 0377)
  160. #define xsendline(c) putchar(c)
  161.  
  162. #endif
  163. #endif
  164.  
  165. #define PATHLEN 256
  166. #define OK 0
  167. #ifdef FALSE
  168. #undef FALSE
  169. #endif
  170. #define FALSE 0
  171. #ifdef TRUE
  172. #undef TRUE
  173. #endif
  174. #define TRUE 1
  175. #define ERROR (-1)
  176. /* Ward Christensen / CP/M parameters - Don't change these! */
  177. #define ENQ 005
  178. #define CAN ('X'&037)
  179. #define XOFF ('s'&037)
  180. #define XON ('q'&037)
  181. #define SOH 1
  182. #define STX 2
  183. #define EOT 4
  184. #define ACK 6
  185. #define NAK 025
  186. #define CPMEOF 032
  187. #define WANTCRC 0103    /* send C not NAK to get crc not checksum */
  188. #define WANTG 0107    /* Send G not NAK to get nonstop batch xmsn */
  189. #define TIMEOUT (-2)
  190. #define RCDO (-3)
  191. #define GCOUNT (-4)
  192. #define RETRYMAX 10
  193.  
  194.  
  195. #define HOWMANY 2
  196. STATIC int Zmodem=0;        /* ZMODEM protocol requested by receiver */
  197. unsigned Baudrate=4800;        /* Default, set by first mode() call */
  198. STATIC unsigned Effbaud = 4800;
  199. STATIC unsigned Txwindow;    /* Control the size of the transmitted window */
  200. STATIC unsigned Txwspac;    /* Spacing between zcrcq requests */
  201. STATIC unsigned Txwcnt;    /* Counter used to space ack requests */
  202. STATIC long Lrxpos;        /* Receiver's last reported offset */
  203. STATIC int errors;
  204.  
  205. #ifdef vax11c
  206. #include "vrzsz.c"    /* most of the system dependent stuff here */
  207. #else
  208. #ifdef GENIE
  209. #include "genie.c"    /* most of the system dependent stuff here */
  210. #else
  211. #include "rbsb.c"    /* most of the system dependent stuff here */
  212. #ifdef XX
  213. #undef STAT
  214. #endif
  215. #endif
  216. #endif
  217.  
  218. #include "crctab.c"
  219.  
  220. STATIC int Filesleft;
  221. STATIC long Totalleft;
  222.  
  223. /*
  224.  * Attention string to be executed by receiver to interrupt streaming data
  225.  *  when an error is detected.  A pause (0336) may be needed before the
  226.  *  ^C (03) or after it.
  227.  */
  228. #ifdef READCHECK
  229. STATIC char Myattn[] = { 0 };
  230. #else
  231. #ifdef USG
  232. STATIC char Myattn[] = { 03, 0336, 0 };
  233. #else
  234. #ifndef GENIE
  235. STATIC char Myattn[] = { 0 };
  236. #endif
  237. #endif
  238. #endif
  239.  
  240. FILE *in;
  241.  
  242. #ifdef BADSEEK
  243. STATIC int Canseek = 0;    /* 1: Can seek 0: only rewind -1: neither (pipe) */
  244. #ifndef TXBSIZE
  245. #define TXBSIZE 16384        /* Must be power of two, < MAXINT */
  246. #endif
  247. #else
  248. STATIC int Canseek = 1;    /* 1: Can seek 0: only rewind -1: neither (pipe) */
  249. #endif
  250.  
  251. #ifdef TXBSIZE
  252. #define TXBMASK (TXBSIZE-1)
  253. STATIC char Txb[TXBSIZE];        /* Circular buffer for file reads */
  254. STATIC char *txbuf = Txb;        /* Pointer to current file segment */
  255. #else
  256. STATIC char txbuf[1024];
  257. #endif
  258. STATIC long vpos = 0;            /* Number of bytes read from file */
  259.  
  260. STATIC char Lastrx;
  261. STATIC char Crcflg;
  262. STATIC int Verbose=0;
  263. STATIC int Modem2=0;        /* XMODEM Protocol - don't send pathnames */
  264. STATIC int Restricted=0;    /* restricted; no /.. or ../ in filenames */
  265. STATIC int Quiet=0;        /* overrides logic that would otherwise set verbose */
  266. STATIC int Ascii=0;        /* Add CR's for brain damaged programs */
  267. STATIC int Fullname=0;        /* transmit full pathname */
  268. STATIC int Unlinkafter=0;    /* Unlink file after it is sent */
  269. STATIC int Dottoslash=0;    /* Change foo.bar.baz to foo/bar/baz */
  270. STATIC int firstsec;
  271. STATIC int errcnt=0;        /* number of files unreadable */
  272. STATIC int blklen=128;        /* length of transmitted records */
  273. STATIC int Optiong;        /* Let it rip no wait for sector ACK's */
  274. STATIC int Eofseen;        /* EOF seen on input set by zfilbuf */
  275. STATIC int BEofseen;        /* EOF seen on input set by fooseek */
  276. STATIC int Totsecs;        /* total number of sectors this file */
  277. STATIC int Filcnt=0;        /* count of number of files opened */
  278. STATIC int Lfseen=0;
  279. STATIC unsigned Rxbuflen = 16384;    /* Receiver's max buffer length */
  280. STATIC int Tframlen = 0;    /* Override for tx frame length */
  281. STATIC int blkopt=0;        /* Override value for zmodem blklen */
  282. STATIC int Rxflags = 0;
  283. STATIC long bytcnt;
  284. STATIC int Wantfcs32 = TRUE;    /* want to send 32 bit FCS */
  285. STATIC char Lzconv;    /* Local ZMODEM file conversion request */
  286. STATIC char Lzmanag;    /* Local ZMODEM file management request */
  287. STATIC int Lskipnocor;
  288. STATIC char Lztrans;
  289. STATIC int Command;        /* Send a command, then exit. */
  290. STATIC char *Cmdstr;        /* Pointer to the command string */
  291. STATIC int Cmdtries = 11;
  292. STATIC int Cmdack1;        /* Rx ACKs command, then do it */
  293. STATIC int Exitcode;
  294. STATIC int Test;        /* 1= Force receiver to send Attn, etc with qbf. */
  295.             /* 2= Character transparency test */
  296. STATIC char *qbf=
  297.  "The quick brown fox jumped over the lazy dog's back 1234567890\r\n";
  298. STATIC long Lastsync;        /* Last offset to which we got a ZRPOS */
  299. STATIC int Beenhereb4;        /* How many times we've been ZRPOS'd same place */
  300.  
  301. STATIC jmp_buf tohere;        /* For the interrupt on RX timeout */
  302. STATIC jmp_buf intrjmp;    /* For the interrupt on RX CAN */
  303.  
  304. #ifdef XARGSFILE
  305. char *
  306. mystrsave(s)
  307. char *s;
  308. {
  309.     register char *p;
  310.     char *malloc();
  311.  
  312.     if (p = malloc(strlen(s)+1) ) {
  313.         strcpy(p, s); return p;
  314.     }
  315.     fprintf(stderr, "No memory for mystrsave!\n");
  316.     exit(1);
  317. }
  318.  
  319. /* Remove (presumably) terminating CR and/or LF from string */
  320. uncrlf(s)
  321. register char *s;
  322. {
  323.     for ( ; *s; ++s)
  324.         switch (*s) {
  325.         case '\r':
  326.         case '\n':
  327.             *s = 0;  return;
  328.         }
  329. }
  330. #endif
  331.  
  332.  
  333. /* called by signal interrupt or terminate to clean things up */
  334. bibi(n)
  335. {
  336.     canit(); fflush(stdout); mode(0);
  337.     fprintf(stderr, "sz: caught signal %d; exiting\n", n);
  338.  
  339. #ifdef NeXT
  340.     { char buf[50];
  341.       sprintf(buf,"Caught signal %d; exiting",n);
  342.       [remote transferMessage:buf];
  343.       sleep(1);
  344.       [remote transferEnd];
  345.     }
  346. #endif
  347.  
  348. #ifndef GENIE
  349.     if (n == SIGQUIT)
  350.         abort();
  351. #endif
  352.     if (n == 99)
  353.         fprintf(stderr, "mode(2) in rbsb.c not implemented!!\n");
  354.     cucheck();
  355.     exit(128+n);
  356. }
  357. /* Called when ZMODEM gets an interrupt (^X) */
  358. onintr()
  359. {
  360.     signal(SIGINT, SIG_IGN);
  361.     longjmp(intrjmp, -1);
  362. }
  363.  
  364. STATIC int Zctlesc;    /* Encode control characters */
  365. STATIC int Nozmodem = 0;    /* If invoked as "sb" */
  366. STATIC char *Progname = "sz";
  367. STATIC int Zrwindow = 1400;    /* RX window size (controls garbage count) */
  368. #include "zm.c"
  369.  
  370. #include "zmr.c"
  371.  
  372. #ifdef XARGSFILE
  373. #define XARGSMAX 256
  374. char *xargv[XARGSMAX+1];
  375. #endif
  376.  
  377. main(argc, argv)
  378. char *argv[];
  379. {
  380.     register char *cp;
  381.     register npats;
  382.     int dm;
  383.     char **patts;
  384.     static char xXbuf[BUFSIZ];
  385.  
  386.     if ((cp = getenv("ZNULLS")) && *cp)
  387.         Znulls = atoi(cp);
  388.     if ((cp=getenv("SHELL")) && (substr(cp, "rsh") || substr(cp, "rksh")))
  389.         Restricted=TRUE;
  390.     from_cu();
  391. #ifdef vax11c
  392.     chkinvok(PROGNAME);
  393. #else
  394.     chkinvok(argv[0]);
  395. #endif
  396.  
  397.     Rxtimeout = 600;
  398.     inittty();
  399.     npats=0;
  400.     if (argc<2)
  401.         usage();
  402.     setbuf(stdout, xXbuf);        
  403.     while (--argc) {
  404.         cp = *++argv;
  405.         if (*cp++ == '-' && *cp) {
  406.             while ( *cp) {
  407.                 switch(*cp++) {
  408.                 case '\\':
  409.                      *cp = toupper(*cp);  continue;
  410.                 case '+':
  411.                     Lzmanag = ZMAPND; break;
  412. #ifdef CSTOPB
  413.                 case '2':
  414.                     Twostop = TRUE; break;
  415. #endif
  416.                 case 'a':
  417.                     Lzconv = ZCNL;
  418.                     Ascii = TRUE; break;
  419.                 case 'b':
  420.                     Lzconv = ZCBIN; break;
  421.                 case 'C':
  422.                     if (--argc < 1) {
  423.                         usage();
  424.                     }
  425.                     Cmdtries = atoi(*++argv);
  426.                     break;
  427.                 case 'i':
  428.                     Cmdack1 = ZCACK1;
  429.                     /* **** FALL THROUGH TO **** */
  430.                 case 'c':
  431.                     if (--argc != 1) {
  432.                         usage();
  433.                     }
  434.                     Command = TRUE;
  435.                     Cmdstr = *++argv;
  436.                     break;
  437.                 case 'd':
  438.                     ++Dottoslash;
  439.                     /* **** FALL THROUGH TO **** */
  440.                 case 'f':
  441.                     Fullname=TRUE; break;
  442.                 case 'e':
  443.                     Zctlesc = 1; break;
  444.                 case 'k':
  445.                     blklen=1024; break;
  446.                 case 'L':
  447.                     if (--argc < 1) {
  448.                         usage();
  449.                     }
  450.                     blkopt = atoi(*++argv);
  451.                     if (blkopt<24 || blkopt>1024)
  452.                         usage();
  453.                     break;
  454.                 case 'l':
  455.                     if (--argc < 1) {
  456.                         usage();
  457.                     }
  458.                     Tframlen = atoi(*++argv);
  459.                     if (Tframlen<32 || Tframlen>1024)
  460.                         usage();
  461.                     break;
  462.                 case 'N':
  463.                     Lzmanag = ZMNEWL;  break;
  464.                 case 'n':
  465.                     Lzmanag = ZMNEW;  break;
  466.                 case 'o':
  467.                     Wantfcs32 = FALSE; break;
  468.                 case 'p':
  469.                     Lzmanag = ZMPROT;  break;
  470.                 case 'r':
  471.                     if (Lzconv == ZCRESUM)
  472.                         Lzmanag = (Lzmanag & ZMMASK) | ZMCRC;
  473.                     Lzconv = ZCRESUM; break;
  474.                 case 'q':
  475.                     Quiet=TRUE; Verbose=0; break;
  476.                 case 't':
  477.                     if (--argc < 1) {
  478.                         usage();
  479.                     }
  480.                     Rxtimeout = atoi(*++argv);
  481.                     if (Rxtimeout<10 || Rxtimeout>1000)
  482.                         usage();
  483.                     break;
  484.                 case 'T':
  485.                     if (++Test > 1) {
  486.                         chartest(1); chartest(2);
  487.                         mode(0);  exit(0);
  488.                     }
  489.                     break;
  490. #ifndef vax11c
  491.                 case 'u':
  492.                     ++Unlinkafter; break;
  493. #endif
  494.                 case 'v':
  495.                     ++Verbose; break;
  496.                 case 'w':
  497.                     if (--argc < 1) {
  498.                         usage();
  499.                     }
  500.                     Txwindow = atoi(*++argv);
  501.                     if (Txwindow < 256)
  502.                         Txwindow = 256;
  503.                     Txwindow = (Txwindow/64) * 64;
  504.                     Txwspac = Txwindow/4;
  505.                     if (blkopt > Txwspac
  506.                      || (!blkopt && Txwspac < 1024))
  507.                         blkopt = Txwspac;
  508.                     break;
  509.                 case 'X':
  510.                     ++Modem2; break;
  511.                 case 'Y':
  512.                     Lskipnocor = TRUE;
  513.                     /* **** FALLL THROUGH TO **** */
  514.                 case 'y':
  515.                     Lzmanag = ZMCLOB; break;
  516.                 case 'Z':
  517.                 case 'z':
  518.                     Lztrans = ZTRLE;  break;
  519.                 default:
  520.                     usage();
  521.                 }
  522.             }
  523.         }
  524.         else if ( !npats && argc>0) {
  525.             if (argv[0][0]) {
  526.                 npats=argc;
  527.                 patts=argv;
  528.             }
  529.         }
  530.     }
  531.     if (npats < 1 && !Command && !Test) 
  532.         usage();
  533.     if (Verbose) {
  534.         if (freopen(LOGFILE, "a", stderr)==NULL) {
  535.             printf("Can't open log file %s\n",LOGFILE);
  536.             exit(0200);
  537.         }
  538.         setbuf(stderr, NULL);
  539.     }
  540.     if (Fromcu && !Quiet) {
  541.         if (Verbose == 0)
  542.             Verbose = 2;
  543.     }
  544.     vfile("%s %s for %s\n", Progname, VERSION, OS);
  545.  
  546. #ifdef NeXT
  547.     [remote transferBegin:Modem2?"XMODEM Send"
  548.                     :(Nozmodem?"YMODEM Send":"ZMODEM Send")];
  549. #endif
  550.  
  551. #ifdef XARGSFILE
  552.     vfile("npats=%d *patts=%s", npats, *patts);
  553.     if (npats == 1 && !strcmp(XARGSFILE, *patts)) {
  554.         in = fopen(XARGSFILE, "r");
  555.         if (!in) {
  556.             printf(stderr, "Can't open / control file!\n");
  557.             exit(2);
  558.         }
  559.         for (npats=0,argv=patts=xargv; npats<XARGSMAX; ++npats,++argv) {
  560.             if (fgets(txbuf, 1024, in) <= 0)
  561.                 break;
  562.             uncrlf(txbuf);
  563.             *argv = mystrsave(txbuf);
  564.         }
  565.         fclose(in);
  566.     }
  567. #endif
  568.  
  569.     mode(1);
  570.  
  571. #ifdef GENIE
  572.     signal(SIGINT, SIG_IGN);
  573. #else
  574.     if (signal(SIGINT, bibi) == SIG_IGN) {
  575.         signal(SIGINT, SIG_IGN); signal(SIGKILL, SIG_IGN);
  576.     } else {
  577.         signal(SIGINT, bibi); signal(SIGKILL, bibi);
  578.     }
  579. #endif
  580. #ifdef SIGQUIT
  581.     if ( !Fromcu)
  582.         signal(SIGQUIT, SIG_IGN);
  583. #endif
  584. #ifdef SIGTERM
  585.     signal(SIGTERM, bibi);
  586. #endif
  587.  
  588.     if ( !Modem2) {
  589.         if (!Nozmodem) {
  590.             printf("rz\r");  fflush(stdout);
  591.         }
  592.         countem(npats, patts);
  593.         if (!Nozmodem) {
  594.             stohdr(0L);
  595.             if (Command)
  596.                 Txhdr[ZF0] = ZCOMMAND;
  597.             zshhdr(4, ZRQINIT, Txhdr);
  598.         }
  599.     }
  600.     fflush(stdout);
  601.  
  602.     if (Command) {
  603.         if (getzrxinit()) {
  604.             Exitcode=0200; canit();
  605.         }
  606.         else if (zsendcmd(Cmdstr, 1+strlen(Cmdstr))) {
  607.             Exitcode=0200; canit();
  608.         }
  609.     } else if (wcsend(npats, patts)==ERROR) {
  610.         Exitcode=0200;
  611.         canit();
  612.     }
  613.     fflush(stdout);
  614.     mode(0);
  615.     dm = ((errcnt != 0) | Exitcode);
  616. #ifdef NeXT
  617.     [remote transferEnd];
  618. #endif
  619.     if (dm) {
  620.         cucheck();  exit(dm);
  621.     }
  622.     exit(SS_NORMAL);
  623.     /*NOTREACHED*/
  624. }
  625.  
  626. wcsend(argc, argp)
  627. char *argp[];
  628. {
  629.     register n;
  630.  
  631.     Crcflg=FALSE;
  632.     firstsec=TRUE;
  633.     bytcnt = -1;
  634.     if (Nozmodem) {
  635.         printf("Start your YMODEM receive. ");  fflush(stdout);
  636.     }
  637.     for (n=0; n<argc; ++n) {
  638.         Totsecs = 0;
  639. #ifdef NeXT
  640.         [remote transferFileBegin:argp[n]];
  641. #endif
  642.         if (wcs(argp[n])==ERROR)
  643.             return ERROR;
  644.     }
  645.     Totsecs = 0;
  646.     if (Filcnt==0) {    /* bitch if we couldn't open ANY files */
  647.         if (!Nozmodem && !Modem2) {
  648.             Command = TRUE;
  649.             Cmdstr = "echo \"sz: Can't open any requested files\"";
  650.             if (getnak()) {
  651.                 Exitcode=0200; canit();
  652.             }
  653.             if (!Zmodem)
  654.                 canit();
  655.             else if (zsendcmd(Cmdstr, 1+strlen(Cmdstr))) {
  656.                 Exitcode=0200; canit();
  657.             }
  658.             Exitcode = 1; return OK;
  659.         }
  660.         canit();
  661.         fprintf(stderr,"\r\nCan't open any requested files.\r\n");
  662.         return ERROR;
  663.     }
  664.     if (Zmodem)
  665.         saybibi();
  666.     else if ( !Modem2)
  667.         wctxpn("");
  668.     return OK;
  669. }
  670.  
  671. wcs(oname)
  672. char *oname;
  673. {
  674.     register c;
  675.     register char *p, *q;
  676. #ifdef STAT
  677.     struct stat f;
  678. #endif
  679.     char name[PATHLEN];
  680.  
  681.     strcpy(name, oname);
  682.  
  683. #ifdef XARGSFILE
  684.     /* Parse GEniename:REALname:length pathname syntax */
  685.     Thisflen = -1;
  686.     for (p = oname; *p; ++p) {
  687.         if (*p == ':') {
  688.             *p++ = 0;
  689.             q = p;
  690.             for (++p; *p; ++p) {
  691.                 if (*p == ':') {
  692.                     *p++ = 0;
  693.                     Thisflen = atol(p);
  694.                     break;
  695.                 }
  696.             }
  697.             strcpy(name, q);
  698.             break;
  699.         }
  700.     }
  701. #endif
  702.  
  703. #ifdef GENIE
  704.     _describe(oname,&fdes);        /* An undocumented goodie */
  705.     if (fdes.type_file == 1) {    /* Fortran Sequential Binary */
  706.         Binfile = 1;
  707.         in = fopen(oname,"rB");
  708.     }
  709.     else if (fdes.type_file == 0)  { /* Ascii */
  710.         Binfile = 0;
  711.         in = fopen(oname,"r");
  712.     }
  713.     else {                /* not a SL filetype */
  714.         fprintf(stderr, "\nUnknown file type %d\n",fdes.type_file);
  715.         ++errcnt;
  716.         return OK;        /* pass over it, there may be others */
  717.     }
  718. #else
  719.     if (Restricted) {
  720.         /* restrict pathnames to current tree or uucppublic */
  721.         if ( substr(name, "../")
  722.          || (name[0]== '/' && strncmp(name, PUBDIR, strlen(PUBDIR))) ) {
  723.             canit();
  724.             fprintf(stderr,"\r\nsz:\tSecurity Violation\r\n");
  725.             return ERROR;
  726.         }
  727.     }
  728.  
  729.     in=fopen(oname, ROPMODE);
  730. #endif
  731.  
  732.     if (in==NULL) {
  733.         ++errcnt;
  734.         return OK;    /* pass over it, there may be others */
  735.     }
  736.     BEofseen = Eofseen = 0;  vpos = 0;
  737.  
  738. #ifdef STAT
  739.     /* Check for directory or block special files */
  740.     fstat(fileno(in), &f);
  741.     c = f.st_mode & S_IFMT;
  742.     if (c == S_IFDIR || c == S_IFBLK) {
  743.         fclose(in);
  744.         return OK;
  745.     }
  746. #endif
  747.  
  748.     ++Filcnt;
  749.     switch (wctxpn(name)) {
  750.     case ERROR:
  751.         return ERROR;
  752.     case ZSKIP:
  753.         return OK;
  754.     }
  755. #ifdef STAT
  756.     if (!Zmodem && wctx(f.st_size)==ERROR)
  757.         return ERROR;
  758. #else
  759.     if (!Zmodem && wctx(1000000000L)==ERROR)
  760.         return ERROR;
  761. #endif
  762.  
  763. #ifndef vax11c
  764. #ifndef GENIE
  765.     if (Unlinkafter)
  766.         unlink(oname);
  767. #endif
  768. #endif
  769.  
  770.     return 0;
  771. }
  772.  
  773. /*
  774.  * generate and transmit pathname block consisting of
  775.  *  pathname (null terminated),
  776.  *  file length, mode time and file mode in octal
  777.  *  as provided by the Unix fstat call.
  778.  *  N.B.: modifies the passed name, may extend it!
  779.  */
  780. wctxpn(name)
  781. char *name;
  782. {
  783.     register char *p, *q;
  784.     char name2[PATHLEN];
  785. #ifdef STAT
  786.     struct stat f;
  787. #endif
  788.  
  789.     if (Modem2) {
  790. #ifdef STAT
  791.         if (*name && fstat(fileno(in), &f)!= -1) {
  792.             fprintf(stderr, "Sending %s, %ld XMODEM blocks. ",
  793.               name, (127+f.st_size)>>7);
  794.         }
  795. #endif
  796.         fprintf(stderr, "Give your local XMODEM receive command now.\r\n");
  797.         fflush(stderr);
  798.         return OK;
  799.     }
  800.     zperr("Awaiting pathname nak for %s", *name?name:"<END>");
  801.     if ( !Zmodem)
  802.         if (getnak())
  803.             return ERROR;
  804.  
  805.     q = (char *) 0;
  806.     if (Dottoslash) {        /* change . to . */
  807.         for (p=name; *p; ++p) {
  808.             if (*p == '/')
  809.                 q = p;
  810.             else if (*p == '.')
  811.                 *(q=p) = '/';
  812.         }
  813.         if (q && strlen(++q) > 8) {    /* If name>8 chars */
  814.             q += 8;            /*   make it .ext */
  815.             strcpy(name2, q);    /* save excess of name */
  816.             *q = '.';
  817.             strcpy(++q, name2);    /* add it back */
  818.         }
  819.     }
  820.  
  821.     for (p=name, q=txbuf ; *p; )
  822.         if ((*q++ = *p++) == '/' && !Fullname)
  823.             q = txbuf;
  824.     *q++ = 0;
  825.     p=q;
  826.     while (q < (txbuf + 1024))
  827.         *q++ = 0;
  828.     if (*name) {
  829. #ifdef XX
  830.         if (Thisflen >= 0) {
  831.             sprintf(p, "%u 0 0 0 %d %ld",
  832.               Thisflen, Filesleft, Totalleft);
  833.             Totalleft -= Thisflen;
  834.         }
  835. #endif
  836. #ifdef GENIE
  837.         else
  838.             sprintf(p, "%d", fdes.current_file_size * 1260);
  839.         vfile("%s open Binfile=%d size=%ld", name, Binfile,
  840.           fdes.current_file_size * 1260);
  841. #endif
  842.  
  843. #ifdef STAT
  844. #ifndef XX
  845.         if (fstat(fileno(in), &f)!= -1)
  846.             sprintf(p, "%lu %lo %o 0 %d %ld", f.st_size, f.st_mtime,
  847.               f.st_mode, Filesleft, Totalleft);
  848.         Totalleft -= f.st_size;
  849. #endif
  850. #endif
  851.  
  852.     }
  853.     if (--Filesleft <= 0)
  854.         Totalleft = 0;
  855.     if (Totalleft < 0)
  856.         Totalleft = 0;
  857.  
  858. #ifdef STAT
  859.     /* force 1k blocks if name won't fit in 128 byte block */
  860.     if (txbuf[125])
  861.         blklen=1024;
  862.     else {        /* A little goodie for IMP/KMD */
  863.         txbuf[127] = (f.st_size + 127) >>7;
  864.         txbuf[126] = (f.st_size + 127) >>15;
  865.     }
  866. #endif
  867.     if (Zmodem)
  868.         return zsendfile(txbuf, 1+strlen(p)+(p-txbuf));
  869.     if (wcputsec(txbuf, 0, 128)==ERROR)
  870.         return ERROR;
  871.     return OK;
  872. }
  873.  
  874. getnak()
  875. {
  876.     register firstch;
  877.  
  878.     Lastrx = 0;
  879.     for (;;) {
  880.         switch (firstch = readline(800)) {
  881.         case ZPAD:
  882.             if (getzrxinit())
  883.                 return ERROR;
  884.             Ascii = 0;    /* Receiver does the conversion */
  885.             return FALSE;
  886.         case TIMEOUT:
  887.             zperr("Timeout on pathname");
  888.             return TRUE;
  889.         case WANTG:
  890. #ifdef MODE2OK
  891.             mode(2);    /* Set cbreak, XON/XOFF, etc. */
  892. #endif
  893.             Optiong = TRUE;
  894.             blklen=1024;
  895.         case WANTCRC:
  896.             Crcflg = TRUE;
  897.         case NAK:
  898.             return FALSE;
  899.         case CAN:
  900.             if ((firstch = readline(20)) == CAN && Lastrx == CAN)
  901.                 return TRUE;
  902.         default:
  903.             break;
  904.         }
  905.         Lastrx = firstch;
  906.     }
  907. }
  908.  
  909.  
  910. wctx(flen)
  911. long flen;
  912. {
  913.     register int thisblklen;
  914.     register int sectnum, attempts, firstch;
  915.     long charssent;
  916.  
  917.     charssent = 0;  firstsec=TRUE;  thisblklen = blklen;
  918.     vfile("wctx:file length=%ld", flen);
  919.  
  920.     while ((firstch=readline(Rxtimeout))!=NAK && firstch != WANTCRC
  921.       && firstch != WANTG && firstch!=TIMEOUT && firstch!=CAN)
  922.         ;
  923.     if (firstch==CAN) {
  924.         zperr("Receiver CANcelled");
  925.         return ERROR;
  926.     }
  927.     if (firstch==WANTCRC)
  928.         Crcflg=TRUE;
  929.     if (firstch==WANTG)
  930.         Crcflg=TRUE;
  931.     sectnum=0;
  932.     for (;;) {
  933.         if (flen <= (charssent + 896L))
  934.             thisblklen = 128;
  935.         if ( !filbuf(txbuf, thisblklen))
  936.             break;
  937.         if (wcputsec(txbuf, ++sectnum, thisblklen)==ERROR)
  938.             return ERROR;
  939.         charssent += thisblklen;
  940.     }
  941.     fclose(in);
  942.     attempts=0;
  943.     do {
  944.         purgeline();
  945.         sendline(EOT);
  946.         flushmo();
  947.         ++attempts;
  948.     }
  949.         while ((firstch=(readline(Rxtimeout)) != ACK) && attempts < RETRYMAX);
  950.     if (attempts == RETRYMAX) {
  951.         zperr("No ACK on EOT");
  952.         return ERROR;
  953.     }
  954.     else
  955.         return OK;
  956. }
  957.  
  958. wcputsec(buf, sectnum, cseclen)
  959. char *buf;
  960. int sectnum;
  961. int cseclen;    /* data length of this sector to send */
  962. {
  963.     register checksum, wcj;
  964.     register char *cp;
  965.     unsigned oldcrc;
  966.     int firstch;
  967.     int attempts;
  968.  
  969.     firstch=0;    /* part of logic to detect CAN CAN */
  970.  
  971. #ifdef NeXT
  972.     [remote transferProgress:Totsecs*blklen];
  973. #endif
  974.     if (Verbose>2)
  975.         fprintf(stderr, "Sector %3d %2dk\n", Totsecs, Totsecs/8 );
  976.     else if (Verbose>1)
  977.         fprintf(stderr, "\rSector %3d %2dk ", Totsecs, Totsecs/8 );
  978.     for (attempts=0; attempts <= RETRYMAX; attempts++) {
  979.         Lastrx= firstch;
  980.         sendline(cseclen==1024?STX:SOH);
  981.         sendline(sectnum);
  982.         sendline(-sectnum -1);
  983.         oldcrc=checksum=0;
  984.         for (wcj=cseclen,cp=buf; --wcj>=0; ) {
  985.             sendline(*cp);
  986.             oldcrc=updcrc((0377& *cp), oldcrc);
  987.             checksum += *cp++;
  988.         }
  989.         if (Crcflg) {
  990.             oldcrc=updcrc(0,updcrc(0,oldcrc));
  991.             sendline((int)oldcrc>>8);
  992.             sendline((int)oldcrc);
  993.         }
  994.         else
  995.             sendline(checksum);
  996.         flushmo();
  997.  
  998.         if (Optiong) {
  999.             firstsec = FALSE; return OK;
  1000.         }
  1001.         firstch = readline(Rxtimeout);
  1002. gotnak:
  1003.         switch (firstch) {
  1004.         case CAN:
  1005.             if(Lastrx == CAN) {
  1006. cancan:
  1007.                 zperr("Cancelled");  return ERROR;
  1008.             }
  1009.             break;
  1010.         case TIMEOUT:
  1011.             zperr("Timeout on sector ACK"); continue;
  1012.         case WANTCRC:
  1013.             if (firstsec)
  1014.                 Crcflg = TRUE;
  1015.         case NAK:
  1016.             zperr("NAK on sector"); continue;
  1017.         case ACK: 
  1018.             firstsec=FALSE;
  1019.             Totsecs += (cseclen>>7);
  1020.             return OK;
  1021.         case ERROR:
  1022.             zperr("Got burst for sector ACK"); break;
  1023.         default:
  1024.             zperr("Got %02x for sector ACK", firstch); break;
  1025.         }
  1026.         for (;;) {
  1027.             Lastrx = firstch;
  1028.             if ((firstch = readline(Rxtimeout)) == TIMEOUT)
  1029.                 break;
  1030.             if (firstch == NAK || firstch == WANTCRC)
  1031.                 goto gotnak;
  1032.             if (firstch == CAN && Lastrx == CAN)
  1033.                 goto cancan;
  1034.         }
  1035.     }
  1036.     zperr("Retry Count Exceeded");
  1037.     return ERROR;
  1038. }
  1039.  
  1040. /* fill buf with count chars padding with ^Z for CPM */
  1041. filbuf(buf, count)
  1042. register char *buf;
  1043. {
  1044.     register c, m;
  1045.  
  1046.     if ( !Ascii) {
  1047.         m = read(fileno(in), buf, count);
  1048.         if (m <= 0)
  1049.             return 0;
  1050.         while (m < count)
  1051.             buf[m++] = 032;
  1052.         return count;
  1053.     }
  1054.     m=count;
  1055.     if (Lfseen) {
  1056.         *buf++ = 012; --m; Lfseen = 0;
  1057.     }
  1058.     while ((c=getc(in))!=EOF) {
  1059.         if (c == 012) {
  1060.             *buf++ = 015;
  1061.             if (--m == 0) {
  1062.                 Lfseen = TRUE; break;
  1063.             }
  1064.         }
  1065.         *buf++ =c;
  1066.         if (--m == 0)
  1067.             break;
  1068.     }
  1069.     if (m==count)
  1070.         return 0;
  1071.     else
  1072.         while (--m>=0)
  1073.             *buf++ = CPMEOF;
  1074.     return count;
  1075. }
  1076.  
  1077. /* Fill buffer with blklen chars */
  1078. zfilbuf()
  1079. {
  1080.     int n;
  1081.  
  1082. #ifdef TXBSIZE
  1083.     vfile("zfilbuf: bytcnt =%lu vpos=%lu blklen=%d", bytcnt, vpos, blklen);
  1084.     /* We assume request is within buffer, or just beyond */
  1085.     txbuf = Txb + (bytcnt & TXBMASK);
  1086.     if (vpos <= bytcnt) {
  1087. #ifdef GENIE
  1088.         if (Binfile) {
  1089.             long l, m;  char *p;
  1090.  
  1091.             for (p=txbuf, n=0, l=blklen;  l;  l -= 128, p+= 128) {
  1092.                 n += m = fgetb(p, 128, in);
  1093.                 if (m == 0)
  1094.                     break;
  1095.             }
  1096.         } else
  1097. #endif
  1098.         n = fread(txbuf, 1, blklen, in);
  1099.  
  1100.         vpos += n;
  1101.         if (n < blklen)
  1102.             Eofseen = 1;
  1103.         vfile("zfilbuf: n=%d vpos=%lu Eofseen=%d", n, vpos, Eofseen);
  1104.         return n;
  1105.     }
  1106.     if (vpos >= (bytcnt+blklen))
  1107.         return blklen;
  1108.     /* May be a short block if crash recovery etc. */
  1109.     Eofseen = BEofseen;
  1110.     return (vpos - bytcnt);
  1111. #else
  1112.     n = fread(txbuf, 1, blklen, in);
  1113.     if (n < blklen)
  1114.         Eofseen = 1;
  1115.     return n;
  1116. #endif
  1117. }
  1118.  
  1119. #ifdef TXBSIZE
  1120. /* Replacement for brain damaged fseek function.  Returns 0==success */
  1121. fooseek(fptr, pos, whence)
  1122. FILE *fptr;
  1123. long pos;
  1124. {
  1125.     long m, n;
  1126. #ifdef GENIE
  1127.     long l, k;  char *p;
  1128. #endif
  1129.  
  1130.     vfile("fooseek: pos =%lu vpos=%lu Canseek=%d", pos, vpos, Canseek);
  1131.     /* Seek offset < current buffer */
  1132.     if (pos < (vpos -TXBSIZE +1024)) {
  1133.         BEofseen = 0;
  1134.         if (Canseek > 0) {
  1135.             vpos = pos & ~TXBMASK;
  1136.             if (vpos >= pos)
  1137.                 vpos -= TXBSIZE;
  1138.             if (fseek(fptr, vpos, 0))
  1139.                 return 1;
  1140.         }
  1141.         else if (Canseek == 0) {
  1142. #ifdef GENIE
  1143.             if (Binfile) {
  1144.                 if (fseekb(fptr, vpos = 0L, 0))
  1145.                     return 1;
  1146.                 } else
  1147. #endif
  1148.             if (fseek(fptr, vpos = 0L, 0))
  1149.                 return 1;
  1150.         } else
  1151.             return 1;
  1152.         while (vpos < pos) {
  1153. #ifdef GENIE
  1154.             if (Binfile) {
  1155.                 for (p=Txb,n=0,l=TXBSIZE; l; l -= 128,p+= 128) {
  1156.                     n += (k = fgetb(p, 128, fptr));
  1157.                     vfile("bsk1: l=%d k=%d", l, k);
  1158.                     if (k == 0)
  1159.                         break;
  1160.                 }
  1161.             } else
  1162. #endif
  1163.             n = fread(Txb, 1, TXBSIZE, fptr);
  1164.             vpos += n;
  1165.             vfile("n=%d vpos=%ld", n, vpos);
  1166.             if (n < TXBSIZE) {
  1167.                 BEofseen = 1;
  1168.                 break;
  1169.             }
  1170.         }
  1171.         vfile("vpos=%ld", vpos);
  1172.         return 0;
  1173.     }
  1174.     /* Seek offset > current buffer (Crash Recovery, etc.) */
  1175.     if (pos > vpos) {
  1176.         if (Canseek)
  1177.             if (fseek(fptr, vpos = (pos & ~TXBMASK), 0))
  1178.                 return 1;
  1179.         while (vpos <= pos) {
  1180.             txbuf = Txb + (vpos & TXBMASK);
  1181.             m = TXBSIZE - (vpos & TXBMASK);
  1182.             vfile("m=%ld vpos=%ld", m,vpos);
  1183. #ifdef GENIE
  1184.             if (Binfile) {
  1185.                 for (p=txbuf,n=0,l=m; l; l -= 128,p+= 128) {
  1186.                     n += (k = fgetb(p, 128, fptr));
  1187.                     vfile("bsk2: l=%d k=%d n=%d", l, k, n);
  1188.                     if (k == 0)
  1189.                         break;
  1190.                 }
  1191.             } else
  1192. #endif
  1193.                 n = fread(txbuf, 1, m, fptr);
  1194.             vfile("n=%ld vpos=%ld", n,vpos);
  1195.             vpos += n;
  1196.             vfile("bo=%d m=%ld vpos=%ld", txbuf-Txb,m,vpos);
  1197.             if (n < m) {
  1198.                 BEofseen = 1;
  1199.                 break;
  1200.             }
  1201.         }
  1202.         return 0;
  1203.     }
  1204.     /* Seek offset is within current buffer */
  1205.     vfile("within buffer: vpos=%ld", vpos);
  1206.     return 0;
  1207. }
  1208. #define fseek fooseek
  1209. #endif
  1210.  
  1211.  
  1212. /* VARARGS1 */
  1213. vfile(f, a, b, c, d)
  1214. register char *f;
  1215. {
  1216.     if (Verbose > 2) {
  1217.         fprintf(stderr, f, a, b, c, d);
  1218.         fprintf(stderr, "\n");
  1219.     }
  1220. }
  1221.  
  1222.  
  1223. alrm()
  1224. {
  1225.     longjmp(tohere, -1);
  1226. }
  1227.  
  1228.  
  1229. #ifndef GENIE
  1230. #ifndef vax11c
  1231. /*
  1232.  * readline(timeout) reads character(s) from file descriptor 0
  1233.  * timeout is in tenths of seconds
  1234.  */
  1235. readline(timeout)
  1236. {
  1237.     register int c;
  1238.     static char byt[1];
  1239.  
  1240.     fflush(stdout);
  1241.     if (setjmp(tohere)) {
  1242.         zperr("TIMEOUT");
  1243.         return TIMEOUT;
  1244.     }
  1245.     c = timeout/10;
  1246.     if (c<2)
  1247.         c=2;
  1248.     if (Verbose>5) {
  1249.         fprintf(stderr, "Timeout=%d Calling alarm(%d) ", timeout, c);
  1250.     }
  1251.     signal(SIGALRM, alrm); alarm(c);
  1252.     c=read(0, byt, 1);
  1253.     alarm(0);
  1254.     if (Verbose>5)
  1255.         fprintf(stderr, "ret %x\n", byt[0]);
  1256.     if (c<1)
  1257.         return TIMEOUT;
  1258.     return (byt[0]&0377);
  1259. }
  1260.  
  1261. flushmo()
  1262. {
  1263.     fflush(stdout);
  1264. }
  1265.  
  1266.  
  1267. purgeline()
  1268. {
  1269. #ifdef USG
  1270.     ioctl(0, TCFLSH, 0);
  1271. #else
  1272.     lseek(0, 0L, 2);
  1273. #endif
  1274. }
  1275. #endif
  1276. #endif
  1277.  
  1278. /* send cancel string to get the other end to shut up */
  1279. canit()
  1280. {
  1281.     static char canistr[] = {
  1282.      24,24,24,24,24,24,24,24,24,24,8,8,8,8,8,8,8,8,8,8,0
  1283.     };
  1284.  
  1285. #ifdef vax11c
  1286.     raw_wbuf(strlen(canistr), canistr);
  1287.     purgeline();
  1288. #else
  1289.     printf(canistr);
  1290.     fflush(stdout);
  1291. #endif
  1292. }
  1293.  
  1294.  
  1295. /*
  1296.  * Log an error
  1297.  */
  1298. /*VARARGS1*/
  1299. zperr(s,p,u)
  1300. char *s, *p, *u;
  1301. {
  1302.     if (Verbose <= 0)
  1303.         return;
  1304.     fprintf(stderr, "Retry %d: ", errors);
  1305.     fprintf(stderr, s, p, u);
  1306.     fprintf(stderr, "\n");
  1307. }
  1308.  
  1309. /*
  1310.  * substr(string, token) searches for token in string s
  1311.  * returns pointer to token within string if found, NULL otherwise
  1312.  */
  1313. char *
  1314. substr(s, t)
  1315. register char *s,*t;
  1316. {
  1317.     register char *ss,*tt;
  1318.     /* search for first char of token */
  1319.     for (ss=s; *s; s++)
  1320.         if (*s == *t)
  1321.             /* compare token with substring */
  1322.             for (ss=s,tt=t; ;) {
  1323.                 if (*tt == 0)
  1324.                     return s;
  1325.                 if (*ss++ != *tt++)
  1326.                     break;
  1327.             }
  1328.     return NULL;
  1329. }
  1330.  
  1331. char *babble[] = {
  1332. #ifdef vax11c
  1333.     "Send file(s) with ZMODEM/YMODEM/XMODEM Protocol",
  1334.     "    (Y) = Option applies to YMODEM only",
  1335.     "    (Z) = Option applies to ZMODEM only",
  1336.     "Usage:    sz [-2+abdefkLlNnquvwYy] [-] file ...",
  1337.     "    sz [-2Ceqv] -c COMMAND",
  1338.     "    \\ Force next option letter to upper case",
  1339.     "    sb [-2adfkquv] [-] file ...",
  1340.     "    sx [-2akquv] [-] file",
  1341. #endif
  1342. #ifndef vax11c
  1343.     "Send file(s) with ZMODEM/YMODEM/XMODEM Protocol",
  1344.     "    (Y) = Option applies to YMODEM only",
  1345.     "    (Z) = Option applies to ZMODEM only",
  1346.     "Usage:    sz [-2+abdefkLlNnquvwYy] [-] file ...",
  1347.     "    sz [-2Ceqv] -c COMMAND",
  1348.     "    sb [-2adfkquv] [-] file ...",
  1349.     "    sx [-2akquv] [-] file",
  1350. #endif
  1351. #ifdef CSTOPB
  1352.     "    2   Use 2 stop bits",
  1353. #endif
  1354.     "    +   Append to existing destination file (Z)",
  1355.     "    a   (ASCII) change NL to CR/LF",
  1356.     "    b   Binary file transfer override",
  1357.     "    c   send COMMAND (Z)",
  1358. #ifndef vax11c
  1359.     "    d   Change '.' to '/' in pathnames (Y/Z)",
  1360. #endif
  1361.     "    e   Escape all control characters (Z)",
  1362.     "    f   send Full pathname (Y/Z)",
  1363.     "    i   send COMMAND, ack Immediately (Z)",
  1364.     "    k   Send 1024 byte packets (Y)",
  1365.     "    L N Limit subpacket length to N bytes (Z)",
  1366.     "    l N Limit frame length to N bytes (l>=L) (Z)",
  1367.     "    n   send file only if source newer (Z)",
  1368.     "    N   send file only if source newer or longer (Z)",
  1369.     "    o   Use 16 bit CRC instead of 32 bit CRC (Z)",
  1370.     "    p   Protect existing destination file (Z)",
  1371.     "    r   Resume/Recover interrupted file transfer (Z)",
  1372.     "    q   Quiet (no progress reports)",
  1373. #ifndef vax11c
  1374.     "    u   Unlink (remove) file after transmission",
  1375. #endif
  1376.     "    v   Verbose - provide debugging information",
  1377.     "    w N restrict Window to N bytes (Z)",
  1378.     "    Y   Yes, overwrite existing file, skip if not present at rx (Z)",
  1379.     "    y   Yes, overwrite existing file (Z)",
  1380.     "    Z   Activate ZMODEM compression(Z)",
  1381.     ""
  1382. };
  1383.  
  1384. usage()
  1385. {
  1386.     char **pp;
  1387.  
  1388.     for (pp=babble; **pp; ++pp)
  1389.         fprintf(stderr, "%s\n", *pp);
  1390.     fprintf(stderr, "%s for %s by Chuck Forsberg, Omen Technology INC\n",
  1391.      VERSION, OS);
  1392.     fprintf(stderr, "\t\t\042The High Reliability Software\042\n");
  1393.     cucheck();
  1394.     exit(SS_NORMAL);
  1395. }
  1396.  
  1397. /*
  1398.  * Get the receiver's init parameters
  1399.  */
  1400. getzrxinit()
  1401. {
  1402.     register n;
  1403. #ifdef STAT
  1404.     struct stat f;
  1405. #endif
  1406.  
  1407.     for (n=10; --n>=0; ) {
  1408.         
  1409.         switch (zgethdr(Rxhdr, 1)) {
  1410.         case ZCHALLENGE:    /* Echo receiver's challenge numbr */
  1411.             stohdr(Rxpos);
  1412.             zshhdr(4, ZACK, Txhdr);
  1413.             continue;
  1414.         case ZCOMMAND:        /* They didn't see out ZRQINIT */
  1415.             stohdr(0L);
  1416.             zshhdr(4, ZRQINIT, Txhdr);
  1417.             continue;
  1418.         case ZRINIT:
  1419.             Rxflags = 0377 & Rxhdr[ZF0];
  1420.             Usevhdrs = Rxhdr[ZF1] & CANVHDR;
  1421.             Txfcs32 = (Wantfcs32 && (Rxflags & CANFC32));
  1422.             Zctlesc |= Rxflags & TESCCTL;
  1423.             Rxbuflen = (0377 & Rxhdr[ZP0])+((0377 & Rxhdr[ZP1])<<8);
  1424.             if ( !(Rxflags & CANFDX))
  1425.                 Txwindow = 0;
  1426.             vfile("Rxbuflen=%d Tframlen=%d", Rxbuflen, Tframlen);
  1427.             if ( !Fromcu)
  1428.                 signal(SIGINT, SIG_IGN);
  1429. #ifdef MODE2OK
  1430.             mode(2);    /* Set cbreak, XON/XOFF, etc. */
  1431. #endif
  1432.  
  1433. #ifndef READCHECK
  1434. #ifndef USG
  1435. #ifndef GENIE
  1436.             /* Use 1024 byte frames if no sample/interrupt */
  1437.             if (Rxbuflen < 32 || Rxbuflen > 1024) {
  1438.                 Rxbuflen = 1024;
  1439.                 vfile("Rxbuflen=%d", Rxbuflen);
  1440.             }
  1441. #endif
  1442. #endif
  1443. #endif
  1444.  
  1445.             /* Override to force shorter frame length */
  1446.             if (Rxbuflen && (Rxbuflen>Tframlen) && (Tframlen>=32))
  1447.                 Rxbuflen = Tframlen;
  1448.             if ( !Rxbuflen && (Tframlen>=32) && (Tframlen<=1024))
  1449.                 Rxbuflen = Tframlen;
  1450.             vfile("Rxbuflen=%d", Rxbuflen);
  1451.  
  1452. #ifndef GENIE
  1453. #ifndef vax11c
  1454. #ifdef STAT
  1455.             /* If using a pipe for testing set lower buf len */
  1456.             fstat(0, &f);
  1457.             if ((f.st_mode & S_IFMT) != S_IFCHR) {
  1458.                 Rxbuflen = 1024;
  1459.             }
  1460. #endif
  1461. #endif
  1462. #endif
  1463.  
  1464. #ifdef BADSEEK
  1465. #ifdef GENIE
  1466.             if (Txwindow == 0) {
  1467.                 Txwspac = (Txwindow = 4096)/4;
  1468.             }
  1469. #else
  1470.             if (Txwindow == 0)
  1471.                 Txwindow = TXBSIZE - 1024;
  1472.             Txwspac = TXBSIZE/4;
  1473. #endif
  1474.             Canseek = 0;
  1475. #endif
  1476.  
  1477.             /*
  1478.              * If input is not a regular file, force ACK's to
  1479.              *  prevent running beyond the buffer limits
  1480.              */
  1481. #ifdef STAT
  1482.             if ( !Command) {
  1483.                 fstat(fileno(in), &f);
  1484.                 if ((f.st_mode & S_IFMT) != S_IFREG) {
  1485.                     Canseek = -1;
  1486. #ifdef TXBSIZE
  1487.                     Txwindow = TXBSIZE - 1024;
  1488.                     Txwspac = TXBSIZE/4;
  1489. #else
  1490.                     return ERROR;
  1491. #endif
  1492.                 }
  1493.             }
  1494. #endif
  1495.  
  1496.             /* Set initial subpacket length */
  1497.             if (blklen < 1024) {    /* Command line override? */
  1498.                 if (Effbaud > 300)
  1499.                     blklen = 256;
  1500.                 if (Effbaud > 1200)
  1501.                     blklen = 512;
  1502.                 if (Effbaud >= 2400)
  1503.                     blklen = 1024;
  1504.             }
  1505.             if (Rxbuflen && blklen>Rxbuflen)
  1506.                 blklen = Rxbuflen;
  1507.             if (blkopt && blklen > blkopt)
  1508.                 blklen = blkopt;
  1509. #ifdef GENIE
  1510.             blklen /= 128;  blklen *= 128;
  1511.             if (blklen < 128)
  1512.                 blklen = 128;
  1513. #endif
  1514.             vfile("Rxbuflen=%d blklen=%d", Rxbuflen, blklen);
  1515.             vfile("Txwindow = %u Txwspac = %d", Txwindow, Txwspac);
  1516.  
  1517.  
  1518.             if (Lztrans == ZTRLE && (Rxflags & CANRLE))
  1519.                 Txfcs32 = 2;
  1520.             else
  1521.                 Lztrans = 0;
  1522.  
  1523.             return (sendzsinit());
  1524.         case ZCAN:
  1525.         case TIMEOUT:
  1526.             return ERROR;
  1527.         case ZRQINIT:
  1528.             if (Rxhdr[ZF0] == ZCOMMAND)
  1529.                 continue;
  1530.         default:
  1531.             zshhdr(4, ZNAK, Txhdr);
  1532.             continue;
  1533.         }
  1534.     }
  1535.     return ERROR;
  1536. }
  1537.  
  1538. /* Send send-init information */
  1539. sendzsinit()
  1540. {
  1541.     register c;
  1542.  
  1543.     if (Myattn[0] == '\0' && (!Zctlesc || (Rxflags & TESCCTL)))
  1544.         return OK;
  1545.     errors = 0;
  1546.     for (;;) {
  1547.         stohdr(0L);
  1548. #ifdef ALTCANOFF
  1549.         Txhdr[ALTCOFF] = ALTCANOFF;
  1550. #endif
  1551.         if (Zctlesc) {
  1552.             Txhdr[ZF0] |= TESCCTL; zshhdr(4, ZSINIT, Txhdr);
  1553.         }
  1554.         else
  1555.             zsbhdr(4, ZSINIT, Txhdr);
  1556.         zsdata(Myattn, ZATTNLEN, ZCRCW);
  1557.         c = zgethdr(Rxhdr, 1);
  1558.         switch (c) {
  1559.         case ZCAN:
  1560.             return ERROR;
  1561.         case ZACK:
  1562.             return OK;
  1563.         default:
  1564.             if (++errors > 19)
  1565.                 return ERROR;
  1566.             continue;
  1567.         }
  1568.     }
  1569. }
  1570.  
  1571. /* Send file name and related info */
  1572. zsendfile(buf, blen)
  1573. char *buf;
  1574. {
  1575.     register c;
  1576.     register UNSL long crc;
  1577.     long lastcrcrq = -1;
  1578.     char *p;
  1579.  
  1580.     for (;;) {
  1581.         Txhdr[ZF0] = Lzconv;    /* file conversion request */
  1582.         Txhdr[ZF1] = Lzmanag;    /* file management request */
  1583.         if (Lskipnocor)
  1584.             Txhdr[ZF1] |= ZMSKNOLOC;
  1585.         Txhdr[ZF2] = Lztrans;    /* file transport request */
  1586.         Txhdr[ZF3] = 0;
  1587.         zsbhdr(4, ZFILE, Txhdr);
  1588.         zsdata(buf, blen, ZCRCW);
  1589. again:
  1590.         c = zgethdr(Rxhdr, 1);
  1591.         switch (c) {
  1592.         case ZRINIT:
  1593.             while ((c = readline(50)) > 0)
  1594.                 if (c == ZPAD) {
  1595.                     goto again;
  1596.                 }
  1597.             /* **** FALL THRU TO **** */
  1598.         default:
  1599.             continue;
  1600.         case ZCAN:
  1601.         case TIMEOUT:
  1602.         case ZABORT:
  1603.         case ZFIN:
  1604.             return ERROR;
  1605.         case ZCRC:
  1606.             if (Rxpos != lastcrcrq) {
  1607.                 lastcrcrq = Rxpos;
  1608.                 crc = 0xFFFFFFFFL;
  1609.                 if (Canseek >= 0) {
  1610.                     fseek(in, 0L, 0);
  1611.                     while (((c = getc(in)) != EOF) && --lastcrcrq)
  1612.                         crc = UPDC32(c, crc);
  1613.                     crc = ~crc;
  1614.                     clearerr(in);    /* Clear possible EOF */
  1615.                     lastcrcrq = Rxpos;
  1616.                 }
  1617.             }
  1618.             stohdr(crc);
  1619.             zsbhdr(4, ZCRC, Txhdr);
  1620.             goto again;
  1621.         case ZSKIP:
  1622.             fclose(in); return c;
  1623.         case ZRPOS:
  1624.             /*
  1625.              * Suppress zcrcw request otherwise triggered by
  1626.              * lastyunc==bytcnt
  1627.              */
  1628. #ifdef GENIE
  1629.             /*
  1630.              *  Special case - turn on RLE if not archive, etc.
  1631.              *   otherwise turn off RLE unless cmd line specified
  1632.              */
  1633.             if (Rxflags & CANRLE) {        /* RX can do it */
  1634.                 bytcnt = 0;
  1635.                 zfilbuf();
  1636.                 vfile("txbuf012: %x %x %x", txbuf[0], txbuf[1],
  1637.                   txbuf[2]);
  1638.                 if ((txbuf[0] != 032)    /* .ARC file */
  1639.                  && (txbuf[0] != 0x1f)    /* .Z file */
  1640.                  && (txbuf[0] != 0x1c)    /* .LHZ file */
  1641.                  && strncmp(txbuf, "ZOO", 3)
  1642.                  && strncmp(txbuf, "GIF", 3)
  1643.                  && (txbuf[2] != 3))    /* .ZIP file */
  1644.                     Txfcs32 = 2;
  1645.                 else if ( !(Lztrans & ZTRLE))
  1646.                     Txfcs32 = 1;
  1647.             }
  1648.             /* GEnie binary can't seek to byte */
  1649.             if (Binfile) {
  1650.                 Rxpos &= ~127L;
  1651.             }
  1652. #endif
  1653.             if (fseek(in, Rxpos, 0))
  1654.                 return ERROR;
  1655.             Lastsync = (bytcnt = Txpos = Lrxpos = Rxpos) -1;
  1656.             return zsendfdata();
  1657.         }
  1658.     }
  1659. }
  1660.  
  1661. /* Send the data in the file */
  1662. zsendfdata()
  1663. {
  1664.     register c, e, n;
  1665.     register newcnt;
  1666.     register long tcount = 0;
  1667.     int junkcount;        /* Counts garbage chars received by TX */
  1668.     static int tleft = 6;    /* Counter for test mode */
  1669.  
  1670.     junkcount = 0;
  1671.     Beenhereb4 = FALSE;
  1672. somemore:
  1673.     if (setjmp(intrjmp)) {
  1674. waitack:
  1675.         junkcount = 0;
  1676.         c = getinsync(0);
  1677. gotack:
  1678.         switch (c) {
  1679.         default:
  1680.         case ZCAN:
  1681.             fclose(in);
  1682.             return ERROR;
  1683.         case ZSKIP:
  1684.             fclose(in);
  1685.             return c;
  1686.         case ZACK:
  1687.         case ZRPOS:
  1688.             break;
  1689.         case ZRINIT:
  1690.             return OK;
  1691.         }
  1692. #ifdef READCHECK
  1693.         /*
  1694.          * If the reverse channel can be tested for data,
  1695.          *  this logic may be used to detect error packets
  1696.          *  sent by the receiver, in place of setjmp/longjmp
  1697.          *  rdchk(fd) returns non 0 if a character is available
  1698.          */
  1699.         while (rdchk(0)) {
  1700. #ifdef EATSIT
  1701.             switch (checked)
  1702. #else
  1703.             switch (readline(1))
  1704. #endif
  1705.             {
  1706.             case CAN:
  1707.             case ZPAD:
  1708.                 c = getinsync(1);
  1709.                 goto gotack;
  1710.             case XOFF:        /* Wait a while for an XON */
  1711.             case XOFF|0200:
  1712.                 readline(100);
  1713.             }
  1714.         }
  1715. #endif
  1716.     }
  1717.  
  1718.     if ( !Fromcu)
  1719.         signal(SIGINT, onintr);
  1720.     newcnt = Rxbuflen;
  1721.     Txwcnt = 0;
  1722.     stohdr(Txpos);
  1723.     zsbhdr(4, ZDATA, Txhdr);
  1724.  
  1725.     /*
  1726.      * Special testing mode.  This should force receiver to Attn,ZRPOS
  1727.      *  many times.  Each time the signal should be caught, causing the
  1728.      *  file to be started over from the beginning.
  1729.      */
  1730.     if (Test) {
  1731.         if ( --tleft)
  1732.             while (tcount < 20000) {
  1733.                 printf(qbf); fflush(stdout);
  1734.                 tcount += strlen(qbf);
  1735. #ifdef READCHECK
  1736.                 while (rdchk(0)) {
  1737. #ifdef EATSIT
  1738.                     switch (checked)
  1739. #else
  1740.                     switch (readline(1))
  1741. #endif
  1742.                     {
  1743.                     case CAN:
  1744.                     case ZPAD:
  1745. #ifdef TCFLSH
  1746.                         ioctl(0, TCFLSH, 1);
  1747. #endif
  1748.                         goto waitack;
  1749.                     case XOFF:    /* Wait for XON */
  1750.                     case XOFF|0200:
  1751.                         readline(100);
  1752.                     }
  1753.                 }
  1754. #endif
  1755.             }
  1756.         signal(SIGINT, SIG_IGN); canit();
  1757.         sleep(3); purgeline(); mode(0);
  1758.         printf("\nsz: Tcount = %ld\n", tcount);
  1759.         if (tleft) {
  1760.             printf("ERROR: Interrupts Not Caught\n");
  1761.             exit(1);
  1762.         }
  1763.         exit(SS_NORMAL);
  1764.     }
  1765.  
  1766.     do {
  1767.         n = zfilbuf();
  1768.         if (Eofseen)
  1769.             e = ZCRCE;
  1770.         else if (junkcount > 3)
  1771.             e = ZCRCW;
  1772.         else if (bytcnt == Lastsync)
  1773.             e = ZCRCW;
  1774.         else if (Rxbuflen && (newcnt -= n) <= 0)
  1775.             e = ZCRCW;
  1776.         else if (Txwindow && (Txwcnt += n) >= Txwspac) {
  1777.             Txwcnt = 0;  e = ZCRCQ;
  1778.         } else
  1779.             e = ZCRCG;
  1780. #ifdef NeXT
  1781.         [remote transferProgress:Txpos];
  1782. #endif
  1783.         if (Verbose>1)
  1784.             fprintf(stderr, "\r%7ld ZMODEM%s    ",
  1785.               Txpos, Crc32t?" CRC-32":"");
  1786.         zsdata(txbuf, n, e);
  1787.         bytcnt = Txpos += n;
  1788.         if (e == ZCRCW)
  1789.             goto waitack;
  1790. #ifdef READCHECK
  1791.         /*
  1792.          * If the reverse channel can be tested for data,
  1793.          *  this logic may be used to detect error packets
  1794.          *  sent by the receiver, in place of setjmp/longjmp
  1795.          *  rdchk(fd) returns non 0 if a character is available
  1796.          */
  1797.         fflush(stdout);
  1798.         while (rdchk(0)) {
  1799. #ifdef EATSIT
  1800.             switch (checked)
  1801. #else
  1802.             switch (readline(1))
  1803. #endif
  1804.             {
  1805.             case CAN:
  1806.             case ZPAD:
  1807.                 c = getinsync(1);
  1808.                 if (c == ZACK)
  1809.                     break;
  1810. #ifdef TCFLSH
  1811.                 ioctl(0, TCFLSH, 1);
  1812. #endif
  1813.                 /* zcrce - dinna wanna starta ping-pong game */
  1814.                 zsdata(txbuf, 0, ZCRCE);
  1815.                 goto gotack;
  1816.             case XOFF:        /* Wait a while for an XON */
  1817.             case XOFF|0200:
  1818.                 readline(100);
  1819.             default:
  1820.                 ++junkcount;
  1821.             }
  1822.         }
  1823. #endif    /* READCHECK */
  1824.         if (Txwindow) {
  1825.             while ((tcount = (Txpos - Lrxpos)) >= Txwindow) {
  1826.                 vfile("%ld window >= %u", tcount, Txwindow);
  1827.                 if (e != ZCRCQ)
  1828.                     zsdata(txbuf, 0, e = ZCRCQ);
  1829.                 c = getinsync(1);
  1830.                 if (c != ZACK) {
  1831. #ifdef TCFLSH
  1832.                     ioctl(0, TCFLSH, 1);
  1833. #endif
  1834.                     zsdata(txbuf, 0, ZCRCE);
  1835.                     goto gotack;
  1836.                 }
  1837.             }
  1838.             vfile("window = %ld", tcount);
  1839.         }
  1840.     } while (!Eofseen);
  1841.     if ( !Fromcu)
  1842.         signal(SIGINT, SIG_IGN);
  1843.  
  1844.     for (;;) {
  1845.         stohdr(Txpos);
  1846.         zsbhdr(4, ZEOF, Txhdr);
  1847.         switch (getinsync(0)) {
  1848.         case ZACK:
  1849.             continue;
  1850.         case ZRPOS:
  1851.             goto somemore;
  1852.         case ZRINIT:
  1853.             return OK;
  1854.         case ZSKIP:
  1855.             fclose(in);
  1856.             return c;
  1857.         default:
  1858.             fclose(in);
  1859.             return ERROR;
  1860.         }
  1861.     }
  1862. }
  1863.  
  1864. /*
  1865.  * Respond to receiver's complaint, get back in sync with receiver
  1866.  */
  1867. getinsync(flag)
  1868. {
  1869.     register c;
  1870.  
  1871.     for (;;) {
  1872.         if (Test) {
  1873.             printf("\r\n\n\n***** Signal Caught *****\r\n");
  1874.             Rxpos = 0; c = ZRPOS;
  1875.         } else
  1876.             c = zgethdr(Rxhdr, 0);
  1877.         switch (c) {
  1878.         case ZCAN:
  1879.         case ZABORT:
  1880.         case ZFIN:
  1881.         case TIMEOUT:
  1882.             return ERROR;
  1883.         case ZRPOS:
  1884.             /* ************************************* */
  1885.             /*  If sending to a buffered modem, you  */
  1886.             /*   might send a break at this point to */
  1887.             /*   dump the modem's buffer.         */
  1888.             clearerr(in);    /* In case file EOF seen */
  1889.             if (fseek(in, Rxpos, 0))
  1890.                 return ERROR;
  1891.             Eofseen = 0;
  1892.             bytcnt = Lrxpos = Txpos = Rxpos;
  1893. #ifndef GENIE
  1894.             if (Lastsync == Rxpos) {
  1895.                 if (++Beenhereb4 > 4)
  1896.                     if (blklen > 32)
  1897.                         blklen /= 2;
  1898.             }
  1899. #endif
  1900.             Lastsync = Rxpos;
  1901.             return c;
  1902.         case ZACK:
  1903.             Lrxpos = Rxpos;
  1904.             if (flag || Txpos == Rxpos)
  1905.                 return ZACK;
  1906.             continue;
  1907.         case ZRINIT:
  1908.         case ZSKIP:
  1909.             fclose(in);
  1910.             return c;
  1911.         case ERROR:
  1912.         default:
  1913.             zsbhdr(4, ZNAK, Txhdr);
  1914.             continue;
  1915.         }
  1916.     }
  1917. }
  1918.  
  1919.  
  1920. /* Say "bibi" to the receiver, try to do it cleanly */
  1921. saybibi()
  1922. {
  1923.     for (;;) {
  1924.         stohdr(0L);        /* CAF Was zsbhdr - minor change */
  1925.         zshhdr(4, ZFIN, Txhdr);    /*  to make debugging easier */
  1926.         switch (zgethdr(Rxhdr, 0)) {
  1927.         case ZFIN:
  1928.             sendline('O'); sendline('O'); flushmo();
  1929.         case ZCAN:
  1930.         case TIMEOUT:
  1931.             return;
  1932.         }
  1933.     }
  1934. }
  1935.  
  1936. /* Local screen character display function */
  1937. bttyout(c)
  1938. {
  1939.     if (Verbose)
  1940.         putc(c, stderr);
  1941. }
  1942.  
  1943. /* Send command and related info */
  1944. zsendcmd(buf, blen)
  1945. char *buf;
  1946. {
  1947.     register c;
  1948.     long cmdnum;
  1949.  
  1950. #ifdef GENIE
  1951.     cmdnum = 69;
  1952. #else
  1953.     cmdnum = getpid();
  1954. #endif
  1955.     errors = 0;
  1956.     for (;;) {
  1957.         stohdr(cmdnum);
  1958.         Txhdr[ZF0] = Cmdack1;
  1959.         zsbhdr(4, ZCOMMAND, Txhdr);
  1960.         zsdata(buf, blen, ZCRCW);
  1961. listen:
  1962.         Rxtimeout = 100;        /* Ten second wait for resp. */
  1963.         Usevhdrs = 0;        /* Allow rx to send fixed len headers */
  1964.         c = zgethdr(Rxhdr, 1);
  1965.  
  1966.         switch (c) {
  1967.         case ZRINIT:
  1968.             goto listen;    /* CAF 8-21-87 */
  1969.         case ERROR:
  1970.         case GCOUNT:
  1971.         case TIMEOUT:
  1972.             if (++errors > Cmdtries)
  1973.                 return ERROR;
  1974.             continue;
  1975.         case ZCAN:
  1976.         case ZABORT:
  1977.         case ZFIN:
  1978.         case ZSKIP:
  1979.         case ZRPOS:
  1980.             return ERROR;
  1981.         default:
  1982.             if (++errors > 20)
  1983.                 return ERROR;
  1984.             continue;
  1985.         case ZCOMPL:
  1986.             Exitcode = Rxpos;
  1987.             saybibi();
  1988.             return OK;
  1989.         case ZRQINIT:
  1990. #ifdef vax11c        /* YAMP :== Yet Another Missing Primitive */
  1991.             return ERROR;
  1992. #else
  1993.             vfile("******** RZ *******");
  1994.             system("rz");
  1995.             vfile("******** SZ *******");
  1996.             goto listen;
  1997. #endif
  1998.         }
  1999.     }
  2000. }
  2001.  
  2002. /*
  2003.  * If called as sb use YMODEM protocol
  2004.  */
  2005. chkinvok(s)
  2006. char *s;
  2007. {
  2008.     register char *p;
  2009.  
  2010.     p = s;
  2011.     while (*p == '-')
  2012.         s = ++p;
  2013.     while (*p)
  2014.         if (*p++ == '/')
  2015.             s = p;
  2016.     if (*s == 'v') {
  2017.         Verbose=1; ++s;
  2018.     }
  2019.     Progname = s;
  2020.     if (s[0]=='s' && s[1]=='b') {
  2021.         Nozmodem = TRUE; blklen=1024;
  2022.     }
  2023.     if (s[0]=='s' && s[1]=='x') {
  2024.         Modem2 = TRUE;
  2025.     }
  2026. }
  2027.  
  2028. #ifdef STAT
  2029. countem(argc, argv)
  2030. register char **argv;
  2031. {
  2032.     register c;
  2033.     struct stat f;
  2034.  
  2035.     for (Totalleft = 0, Filesleft = 0; --argc >=0; ++argv) {
  2036.         f.st_size = -1;
  2037.         if (Verbose>2) {
  2038.             fprintf(stderr, "\nCountem: %03d %s ", argc, *argv);
  2039.             fflush(stderr);
  2040.         }
  2041.         if (access(*argv, 04) >= 0 && stat(*argv, &f) >= 0) {
  2042.             c = f.st_mode & S_IFMT;
  2043.             if (c != S_IFDIR && c != S_IFBLK) {
  2044.                 ++Filesleft;  Totalleft += f.st_size;
  2045.             }
  2046.         }
  2047. #ifdef NeXT
  2048.         [remote transferFile:*argv size:f.st_size];
  2049. #endif
  2050.         if (Verbose>2)
  2051.             fprintf(stderr, " %ld", f.st_size);
  2052.     }
  2053.     if (Verbose>2)
  2054.         fprintf(stderr, "\ncountem: Total %d %ld\n",
  2055.           Filesleft, Totalleft);
  2056. }
  2057. #else
  2058. countem(argc, argv)
  2059. register char **argv;
  2060. {
  2061.     register c;
  2062.     register char *p;
  2063.     long size;
  2064.  
  2065.     for (Totalleft = 0, Filesleft = 0; --argc >=0; ++argv) {
  2066.         size = -1;
  2067.         if (Verbose>2) {
  2068.             fprintf(stderr, "\nCountem: %03d %s ", argc, *argv);
  2069.             fflush(stderr);
  2070.         }
  2071.         ++Filesleft;  
  2072. #ifdef XARGSFILE
  2073.         /* Look for file length in third colon sep field */
  2074.         for (p = *argv; *p; ++p) {
  2075.             if (*p == ':') {
  2076.                 for (++p; *p; ++p) {
  2077.                     if (*p == ':') {
  2078.                         ++p;
  2079.                         size = atol(p);
  2080.                         Totalleft += size;
  2081.                         break;
  2082.                     }
  2083.                 }
  2084.             break;
  2085.             }
  2086.         }
  2087. #endif
  2088.  
  2089.         if (Verbose>2)
  2090.             fprintf(stderr, " %ld", size);
  2091.     }
  2092.     if (Verbose>2)
  2093.         fprintf(stderr, "\ncountem: Total %d %ld\n",
  2094.           Filesleft, Totalleft);
  2095. }
  2096. #endif
  2097.  
  2098. chartest(m)
  2099. {
  2100.     register n;
  2101.  
  2102.     mode(m);
  2103.     printf("\r\n\nCharacter Transparency Test Mode %d\r\n", m);
  2104.     printf("If Pro-YAM/ZCOMM is not displaying ^M hit ALT-V NOW.\r\n");
  2105.     printf("Hit Enter.\021");  fflush(stdout);
  2106.     readline(500);
  2107.  
  2108.     for (n = 0; n < 256; ++n) {
  2109.         if (!(n%8))
  2110.             printf("\r\n");
  2111.         printf("%02x ", n);  fflush(stdout);
  2112.         sendline(n);    flushmo();
  2113.         printf("  ");  fflush(stdout);
  2114.         if (n == 127) {
  2115.             printf("Hit Enter.\021");  fflush(stdout);
  2116.             readline(500);
  2117.             printf("\r\n");  fflush(stdout);
  2118.         }
  2119.     }
  2120.     printf("\021\r\nEnter Characters, echo is in hex.\r\n");
  2121.     printf("Hit SPACE or pause 40 seconds for exit.\r\n");
  2122.  
  2123.     while (n != TIMEOUT && n != ' ') {
  2124.         n = readline(400);
  2125.         printf("%02x\r\n", n);
  2126.         fflush(stdout);
  2127.     }
  2128.     printf("\r\nMode %d character transparency test ends.\r\n", m);
  2129.     fflush(stdout);
  2130. }
  2131.  
  2132. /* End of sz.c */
  2133.